package com.lk;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 *一、线程池：提供一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外的开销，提高响应速度。
 *
 * 二、线程池的结构
 *      java.util.concurrent.Executor:负责线程的使用与调度的根接口
 *          |--**ExecutorService子接口：线程池的主要接口
 *              |--**ThreadPoolExecutor线程池的实现类
 *              |--**ScheduledExecutorService子接口 负责线程的调度
 *                  |--**ScheduledThreadPoolExecutor 继承ThreadPoolExecutor 实现ScheduledExecutorService子接口
 *
 * 三、工具类：Executor
 * Executors newFixedThreadPool ：创建固定大小的线程池
 * Executors newCachedThreadPool:缓存线程池，线程池的数量固定，可以根据需求自动的更改数量
 * Executors newSingleThreadExecutor:创建单个线程池。线程池中只有一个线程
 *
 * ScheduledExecutorService newScheduledThreadPool():创建固定大小的线程，可以延迟或定时的执行任务
 * */
public class TestThreadPool {

    public static void main(String[] args) {
        ExecutorService pools = Executors.newFixedThreadPool(5);

        List<Future> list = new ArrayList<>();

        for (int j = 0; j < 10; j++) {
            Future<Integer> future = pools.submit(()->{
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum+=i;
                }
                return sum;
            });
            list.add(future);
        }

        list.forEach(future-> {
            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });

        /*ThreadPoolDemo threadPoolDemo = new ThreadPoolDemo();

        for(int i=0 ; i <100; i++ ){
            pools.submit(threadPoolDemo);
        }
        pools.shutdown();*/
//        ExecutorService pools = new ThreadPoolExecutor();
    }

}

class ThreadPoolDemo implements Runnable{

    private int num = 0;

    @Override
    public void run() {
        if (num<=100){
            System.out.println(Thread.currentThread().getName()+" "+ ++num);
        }
    }
}
